package com.atguigu.gmall.cart.service.impl;

import com.atguigu.gmall.cart.mapper.CartInfoMapper;
import com.atguigu.gmall.cart.service.CartInfoService;
import com.atguigu.gmall.model.cart.CartInfo;
import com.atguigu.gmall.model.product.SkuInfo;
import com.atguigu.gmall.product.client.ProductClientFeign;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Author: lx
 * @Time: 14:02
 * @Description:
 */
@Service
public class CartInfoServiceImpl implements CartInfoService {

    @Autowired
    private CartInfoMapper cartInfoMapper;
    @Autowired
    private ProductClientFeign productClientFeign;
    @Autowired
    private RedisTemplate redisTemplate;

    //加入购物车
    @Override
    public void addCart(Long skuId, Integer skuNum, String userId) {

        //1:查询缓存  如果没有
        //List<CartInfo> cartInfoList = redisTemplate.opsForHash().values(userId);
        //1: 先查询 当前用户的购物车集合
        List<CartInfo> cartInfoList = cartInfoMapper.selectList(
                new QueryWrapper<CartInfo>().eq("user_id", userId));
        if (!CollectionUtils.isEmpty(cartInfoList)) {
            //2: 判断当前正在添加的商品 是否在购物车集合中是否存在
            for (CartInfo cartInfo : cartInfoList) {
                if (cartInfo.getSkuId() == skuId) {
                    //追加数量
                    cartInfo.setSkuNum(cartInfo.getSkuNum() + skuNum);
                    //不管之前的状态  现在的状态是选中
                    cartInfo.setIsChecked(1);
                    //更新Mysql数据库
                    cartInfoMapper.updateById(cartInfo);
                    return;
                }
            }
        }
        //当成新商品添加
        //4:不存在  当新商品添加
        CartInfo cartInfo = new CartInfo();
        //用户ID
        cartInfo.setUserId(userId);
        //库存ID
        cartInfo.setSkuId(skuId);
        //数量
        cartInfo.setSkuNum(skuNum);
        //购物车价格 ？  商品第一次保存到购物中时候的价格
        //查询时时价格
        SkuInfo skuInfo = productClientFeign.getSkuInfo(skuId);
        cartInfo.setCartPrice(skuInfo.getPrice());
        //图片
        cartInfo.setImgUrl(skuInfo.getSkuDefaultImg());
        //名称
        cartInfo.setSkuName(skuInfo.getSkuName());
        //选中
        cartInfo.setIsChecked(1);
        //保存
        cartInfoMapper.insert(cartInfo);

        //更新缓存   设置过期时间


        //返回值：当前购物车
        //return cartInfo;
    }

    //查询购物车
    @Override
    public CartInfo getCartInfo(Long skuId, Integer skuNum, String userId) {
        CartInfo cartInfo = cartInfoMapper.selectOne(new QueryWrapper<CartInfo>()
                .eq("user_id", userId)
                .eq("sku_id", skuId));
        //CartInfo cartInfo1 = (CartInfo) redisTemplate.opsForHash().get(userId,skuId);
        //本次购买的数量
        cartInfo.setSkuNum(skuNum);
        return cartInfo;
    }

    //查询购物车列表集合
    @Override
    public List<CartInfo> cartList(String userId, String userTempId) {
        List<CartInfo> cartInfoList = null;
        //1:用户未登录
        if(StringUtils.isEmpty(userId)){
            //2：查询临时用户的购物车集合
           cartInfoList = findCartInfo(userTempId);
        }else{
            //用户登录了
            if(StringUtils.isEmpty(userTempId)){
                //3：没有临时用户 查询永久用户的购物车集合
                cartInfoList = findCartInfo(userId);
            }else{
                //4：查询永久用户的购物车集合及临时用户的购物车集合 之 和
                cartInfoList = mergeCartInfoList(userId,userTempId);
            }
        }
        return cartInfoList;
    }
    //选中或取消
    @Override
    public void checkCart(Long skuId, Integer isChecked, String userId) {
        CartInfo cartInfo = new CartInfo();
        cartInfo.setIsChecked(isChecked);
        cartInfoMapper.update(cartInfo,new QueryWrapper<CartInfo>()
         .eq("sku_id",skuId).eq("user_id",userId));
    }
    //商品清单
    @Override
    public List<CartInfo> getCartCheckedList(String userId) {
        List<CartInfo> cartInfoList = cartInfoMapper.selectList(new QueryWrapper<CartInfo>().eq("user_id", userId)
                .eq("is_checked", 1));
        if(!CollectionUtils.isEmpty(cartInfoList)){
            cartInfoList.forEach((cartInfo) -> {
                //实时价格
                cartInfo.setSkuPrice(productClientFeign.getPrice(cartInfo.getSkuId()));
            });
        }
        return cartInfoList;
    }

    //查询永久用户的购物车集合及临时用户的购物车集合 之 和
    private List<CartInfo> mergeCartInfoList(String userId, String userTempId) {
        //1:查询永久用户的购物车集合
        List<CartInfo> cartInfoListByUserId = findCartInfo(userId);
       //2:查询临时用户的购物车集合
        List<CartInfo> cartInfoListByUserTempId = findCartInfo(userTempId);
        //3:判断购物车集合是否有值
        if(CollectionUtils.isEmpty(cartInfoListByUserId)){
            //1）临时用户的购物车不为空的时候  才需要更新 临时用户的购物车集合 为 永久用户的
            if(!CollectionUtils.isEmpty(cartInfoListByUserTempId)){
                //开始更新
                //批量   参数1： 更新的字段  参数2：更新的条件
                  //  udpate 表名 set user_id = ? where  user_id = ?
                CartInfo cartInfo = new CartInfo();
                cartInfo.setUserId(userId);
                cartInfoMapper.update(cartInfo,
                        new QueryWrapper<CartInfo>().eq("user_id",userTempId));
                //一个一个更新
            }
            //2）页面购物车 回显数据
            return cartInfoListByUserTempId;
        }else{
            //4：永久用户有购物车集合
            if(CollectionUtils.isEmpty(cartInfoListByUserTempId)){
                //临时用户的购物车集合是没有
                return cartInfoListByUserId;
            }else{
                //5：永久用户与临时用户都有购物车集合 大合并  二大集合合并
                // 将永久用户的购物车集合转成Map 类型  K：skuId V:CartInfo
                Map<Long, CartInfo> cartInfoMapByUserId = cartInfoListByUserId.
                        stream().collect(Collectors.toMap(
                        CartInfo::getSkuId, (cartInfo) -> {
                            return cartInfo;
                        }
                ));
                //临时用户购物车集合遍历中
                cartInfoListByUserTempId.forEach((cartInfoByUserTempId) -> {
                    //判断在永久用户购物车集合中是否已经存在了
                    CartInfo cartInfoByUserId = cartInfoMapByUserId.
                            get(cartInfoByUserTempId.getSkuId());
                    if(null != cartInfoByUserId){
                        //-- 存在了 追加数量
                        cartInfoByUserId.setSkuNum(
                                cartInfoByUserId.getSkuNum() +
                                        cartInfoByUserTempId.getSkuNum());
                        //选中
                        cartInfoByUserId.setIsChecked(1);
                        //更新DB
                        //update  永久
                        cartInfoMapper.updateById(cartInfoByUserId);
                        //delete  临时
                        cartInfoMapper.deleteById(cartInfoByUserTempId.getId());
                    }else{
                        //-- 不存在  新款商品添加
                        cartInfoMapByUserId.put(cartInfoByUserTempId.getSkuId()
                                ,cartInfoByUserTempId);
                        //更新DB
                        // update  临时
                        cartInfoByUserTempId.setUserId(userId);
                        cartInfoMapper.updateById(cartInfoByUserTempId);
                    }
                });
                return new ArrayList<>(cartInfoMapByUserId.values());
            }
        }
    }

    //查询用户购物车集合  参数  ： 用户ID的意思  （是什么用户暂不考虑）
    private List<CartInfo> findCartInfo(String uid) {

        //1:从缓存查询

        List<CartInfo> cartInfoList =
                cartInfoMapper.selectList(new QueryWrapper<CartInfo>()
                        .eq("user_id", uid));

        //2：缓存中有购物车 也应该重新查询实时价格
        if(!CollectionUtils.isEmpty(cartInfoList)){
            cartInfoList.forEach((cartInfo) -> {
                //实时价格
                cartInfo.setSkuPrice(productClientFeign.getPrice(cartInfo.getSkuId()));
            });
        }
        return cartInfoList;
    }

}
